home *** CD-ROM | disk | FTP | other *** search
/ PC go! 2018 July / PCgo 07-2018 CD-ROM Germany.iso / nw.pak / Unnamed File 004905.txt < prev    next >
Encoding:
Text File  |  2015-07-29  |  6.7 KB  |  185 lines
  1. // Copyright 2014 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4.  
  5. define("device/serial/serial_serialization.mojom", [
  6.     "mojo/public/js/bindings",
  7.     "mojo/public/js/codec",
  8.     "mojo/public/js/connection",
  9.     "mojo/public/js/core",
  10.     "mojo/public/js/validator",
  11.     "device/serial/serial.mojom",
  12.     "device/serial/data_stream_serialization.mojom",
  13. ], function(bindings, codec, connection, core, validator, serial, data_stream_serialization) {
  14.  
  15.   function ConnectionState(values) {
  16.     this.initDefaults_();
  17.     this.initFields_(values);
  18.   }
  19.  
  20.  
  21.   ConnectionState.prototype.initDefaults_ = function() {
  22.     this.connectionId = 0;
  23.     this.paused = false;
  24.     this.persistent = false;
  25.     this.name = "";
  26.     this.receiveTimeout = 0;
  27.     this.sendTimeout = 0;
  28.     this.bufferSize = 4096;
  29.   };
  30.   ConnectionState.prototype.initFields_ = function(fields) {
  31.     for(var field in fields) {
  32.         if (this.hasOwnProperty(field))
  33.           this[field] = fields[field];
  34.     }
  35.   };
  36.  
  37.   ConnectionState.validate = function(messageValidator, offset) {
  38.     var err;
  39.  
  40.     err = messageValidator.validateStructHeader(offset, ConnectionState.encodedSize, 7);
  41.     if (err !== validator.validationError.NONE)
  42.         return err;
  43.     // validate ConnectionState.name
  44.     err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 8, false)
  45.     if (err !== validator.validationError.NONE)
  46.         return err;
  47.  
  48.     return validator.validationError.NONE;
  49.   };
  50.  
  51.   ConnectionState.encodedSize = codec.kStructHeaderSize + 32;
  52.  
  53.   ConnectionState.decode = function(decoder) {
  54.     var packed;
  55.     var val = new ConnectionState();
  56.     var numberOfBytes = decoder.readUint32();
  57.     var numberOfFields = decoder.readUint32();
  58.     val.connectionId = decoder.decodeStruct(codec.Uint32);
  59.     packed = decoder.readUint8();
  60.     val.paused = (packed >> 0) & 1 ? true : false;
  61.     val.persistent = (packed >> 1) & 1 ? true : false;
  62.     decoder.skip(1);
  63.     decoder.skip(1);
  64.     decoder.skip(1);
  65.     val.name = decoder.decodeStruct(codec.String);
  66.     val.receiveTimeout = decoder.decodeStruct(codec.Uint32);
  67.     val.sendTimeout = decoder.decodeStruct(codec.Uint32);
  68.     val.bufferSize = decoder.decodeStruct(codec.Uint32);
  69.     decoder.skip(1);
  70.     decoder.skip(1);
  71.     decoder.skip(1);
  72.     decoder.skip(1);
  73.     return val;
  74.   };
  75.  
  76.   ConnectionState.encode = function(encoder, val) {
  77.     var packed;
  78.     encoder.writeUint32(ConnectionState.encodedSize);
  79.     encoder.writeUint32(7);
  80.     encoder.encodeStruct(codec.Uint32, val.connectionId);
  81.     packed = 0;
  82.     packed |= (val.paused & 1) << 0
  83.     packed |= (val.persistent & 1) << 1
  84.     encoder.writeUint8(packed);
  85.     encoder.skip(1);
  86.     encoder.skip(1);
  87.     encoder.skip(1);
  88.     encoder.encodeStruct(codec.String, val.name);
  89.     encoder.encodeStruct(codec.Uint32, val.receiveTimeout);
  90.     encoder.encodeStruct(codec.Uint32, val.sendTimeout);
  91.     encoder.encodeStruct(codec.Uint32, val.bufferSize);
  92.     encoder.skip(1);
  93.     encoder.skip(1);
  94.     encoder.skip(1);
  95.     encoder.skip(1);
  96.   };
  97.  
  98.   function SerializedConnection(values) {
  99.     this.initDefaults_();
  100.     this.initFields_(values);
  101.   }
  102.  
  103.  
  104.   SerializedConnection.prototype.initDefaults_ = function() {
  105.     this.state = null;
  106.     this.queuedReceiveError = serial.ReceiveError.NONE;
  107.     this.connection = null;
  108.     this.queuedReceiveData = null;
  109.     this.sender = null;
  110.     this.receiver = null;
  111.   };
  112.   SerializedConnection.prototype.initFields_ = function(fields) {
  113.     for(var field in fields) {
  114.         if (this.hasOwnProperty(field))
  115.           this[field] = fields[field];
  116.     }
  117.   };
  118.  
  119.   SerializedConnection.validate = function(messageValidator, offset) {
  120.     var err;
  121.  
  122.     err = messageValidator.validateStructHeader(offset, SerializedConnection.encodedSize, 6);
  123.     if (err !== validator.validationError.NONE)
  124.         return err;
  125.     // validate SerializedConnection.state
  126.     err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 0, ConnectionState, false);
  127.     if (err !== validator.validationError.NONE)
  128.         return err;
  129.     // validate SerializedConnection.connection
  130.     err = messageValidator.validateHandle(offset + codec.kStructHeaderSize + 12, false)
  131.     if (err !== validator.validationError.NONE)
  132.         return err;
  133.     // validate SerializedConnection.queuedReceiveData
  134.     err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 16, 1, codec.Int8, true, [0], 0);
  135.     if (err !== validator.validationError.NONE)
  136.         return err;
  137.     // validate SerializedConnection.sender
  138.     err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 24, data_stream_serialization.SerializedDataSender, false);
  139.     if (err !== validator.validationError.NONE)
  140.         return err;
  141.     // validate SerializedConnection.receiver
  142.     err = messageValidator.validateStructPointer(offset + codec.kStructHeaderSize + 32, data_stream_serialization.SerializedDataReceiver, false);
  143.     if (err !== validator.validationError.NONE)
  144.         return err;
  145.  
  146.     return validator.validationError.NONE;
  147.   };
  148.  
  149.   SerializedConnection.encodedSize = codec.kStructHeaderSize + 40;
  150.  
  151.   SerializedConnection.decode = function(decoder) {
  152.     var packed;
  153.     var val = new SerializedConnection();
  154.     var numberOfBytes = decoder.readUint32();
  155.     var numberOfFields = decoder.readUint32();
  156.     val.state = decoder.decodeStructPointer(ConnectionState);
  157.     val.queuedReceiveError = decoder.decodeStruct(codec.Int32);
  158.     val.connection = decoder.decodeStruct(codec.Handle);
  159.     val.queuedReceiveData = decoder.decodeArrayPointer(codec.Int8);
  160.     val.sender = decoder.decodeStructPointer(data_stream_serialization.SerializedDataSender);
  161.     val.receiver = decoder.decodeStructPointer(data_stream_serialization.SerializedDataReceiver);
  162.     return val;
  163.   };
  164.  
  165.   SerializedConnection.encode = function(encoder, val) {
  166.     var packed;
  167.     encoder.writeUint32(SerializedConnection.encodedSize);
  168.     encoder.writeUint32(6);
  169.     encoder.encodeStructPointer(ConnectionState, val.state);
  170.     encoder.encodeStruct(codec.Int32, val.queuedReceiveError);
  171.     encoder.encodeStruct(codec.Handle, val.connection);
  172.     encoder.encodeArrayPointer(codec.Int8, val.queuedReceiveData);
  173.     encoder.encodeStructPointer(data_stream_serialization.SerializedDataSender, val.sender);
  174.     encoder.encodeStructPointer(data_stream_serialization.SerializedDataReceiver, val.receiver);
  175.   };
  176.  
  177.  
  178.   var exports = {};
  179.   exports.ConnectionState = ConnectionState;
  180.   exports.SerializedConnection = SerializedConnection;
  181.  
  182.  
  183.   return exports;
  184. });
  185.